KvmDevice.idl

#ifndef __RADM_KVM_DEVICE_IDL__
#define __RADM_KVM_DEVICE_IDL__
 
#include <Device.idl>
#include <KvmPort.idl>
#include <LocalMonitor.idl>
#include <LocalPort.idl>
#include <TerminalBlock.idl>
#include <UsbProfileSettings.idl>
#include <VideoResolution.idl>
 
module radm {
 
    interface KvmDevice extends Device {
 
        constant int ERR_EDID_DATA_IN_USE   = 10; ///< EDID data is in use, cannot be deleted
        constant int ERR_EDID_GENERATION_FAILED  = 11; ///< Failed to generate custom EDID
 
        structure CustomEdidLimits {
            int maxWidth;
            int maxHeight;
            int minWidth;
            int minHeight;
            int maxFrameRate;
            int minFrameRate;
            double maxPixelClock;
            double minPixelClock;
            int maxPixels;
        };
 
        enumeration EdidInterfaceType {
            DVI,    ///< DVI EDID data
            HDMI    ///< HDMI EDID data
        };
 
        /** EDID data for a given resolution */
        structure EdidData {
            VideoResolution resolution;         ///< Resolution described by the EDID data
            string description;                 ///< Text describing the EDID data
            EdidInterfaceType videoInterface;   ///< Video interface type the EDID data is meant for
        };
 
        /** An uploaded USB profile */
        structure UsbProfile {
            long key;                           ///< Profile key
            int id;                             ///< Profile ID
            string name;                        ///< Profile name
            string description;                 ///< Profile description
            boolean systemProfile;              ///< Whether the profile is a system (built-in) profile
            UsbProfileSettings settings;        ///< Profile settings
        };
 
        /** Device temperature reading */
        structure TemperatureReading {
            boolean available;          ///< Whether the reading data is valid
            float currentValue;         ///< Current device temperature (in degree Celsius)
            float maximumValue;         ///< Historical temperature maximum (in degree Celsius)
            float minimumValue;         ///< Historical temperature minimum (in degree Celsius)
        };
 
        /**
         * Get KVM ports of this device
         *
         * @return List of KVM ports
         */
        vector<KvmPort> getKvmPorts();
 
        /**
         * Get monitor(s) locally attached to the device
         *
         * @return List of locally attached monitors
         */
        vector<LocalMonitor> getLocalMonitors();
 
        /**
         * Gets local control port of the device
         *
         * @return Local port if present on the device
         */
        LocalPort getLocalPort();
 
        /**
         * Get the terminal block of the device
         *
         * @return Terminal block if present on the device
         */
        TerminalBlock getTerminalBlock();
 
        /**
         * Get the device's internal temperature
         *
         * @return Device temperature reading
         */
        TemperatureReading getInternalTemperature();
 
        /**
         * Get data of the video resolutions supported by the device
         *
         * @return List of EDID data built into the device
         */
        vector<EdidData> getSupportedResolutionData();
 
        /**
         * Get data of the video resolution data uploaded to the device
         *
         * @return List of custom EDID data
         */
        vector<EdidData> getCustomEdidData();
 
        /**
         * Delete previously uploaded custom EDID data
         *
         * @param resolution Video resolution to delete
         * @param videoInterface Interface type to delete resolution for
         *
         * @return 0 on success
         * @return 1 if the given resolution/interface combination could not be found
         * @return 10 if the given resolution/interface combination currently is in use
         */
        int deleteCustomEdidData(in VideoResolution resolution, in EdidInterfaceType videoInterface);
 
        /**
         * Create custom EDID
         *
         * @param resolution Resolution for custom EDID
         *
         * @return 0 if success
         * @return 1 if no valid EDID can be generated from the provided resolution
         * @return 2 if custom EDID data generation is not supported
         * @return 11 if there was an internal error while generating the EDID data
         */
        int createCustomEdid(in VideoResolution resolution);
 
        /**
         * Validate custom EDID argument and calculate pixel clock
         *
         * @param resolution Resolution for custom EDID
         * @param resultingPixelClock Pixel clock calculated if valid (output)
         *
         * @return 0 if validation successful
         * @return 1 if the provided resolution is not valid for EDID generation
         * @return 2 if if custom EDID data generation is not supported
         */
        int validateCustomEdidArgument(in VideoResolution resolution, out double resultingPixelClock);
 
        /**
         * Get limits for custom EDID generation
         *
         * @return limits
         */
        CustomEdidLimits getCustomEdidLimits();
 
        /**
         * Get USB profiles available on the device
         *
         * @return USB profiles, or an empty list in case USB profiles are not supported
         */
        vector<UsbProfile> getUsbProfiles();
 
        /**
         * Delete a previously uploaded USB profile
         *
         * @param Profile ID of the profile to be deleted
         *
         * @return 0 on success
         * @return 1 if the profile with the given ID could not be found
         */
        int deleteUsbProfile(in int profileId);
 
        /** Event: The list of available USB profiles changed */
        valueobject UsbProfilesChangedEvent extends event.UserEvent {
            vector<UsbProfile> newUsbProfiles; ///< USB profile list after the change
        };
 
        /** Event: A USB profile was added */
        valueobject UsbProfileAddedEvent extends UsbProfilesChangedEvent {
            UsbProfile profile;     ///< Added profile
        };
 
        /** Event: A USB profile was deleted */
        valueobject UsbProfileDeletedEvent extends UsbProfilesChangedEvent {
            UsbProfile deletedProfile;      ///< Deleted profile
        };
 
        /** Event: Custom EDID data changed */
        valueobject CustomEdidDataChangedEvent extends event.UserEvent {
            vector<EdidData> newCustomEdidData;  ///< List of custom EDID data after the change
        };
 
        /** Event: Device temperature has changed */
        valueobject TemperatureChangedEvent extends idl.Event {
            TemperatureReading newReading;      ///< Device temperature reading after the change
        };
    };
 
}
 
#endif //__RADM_KVM_DEVICE_IDL__